/**
 * data_helper.js
 * 数据处理工具 - PLM项目专用
 */

// 导入路径解析器
const pathResolver = require('../config/path_resolver.js').getRootConfigPath('path_resolver.js').getRootConfigPath('path_resolver.js');

// 尝试加载项目helper
let helper;
try {
  helper = require('./helper.js');
  console.log('成功加载项目helper');
} catch (e) {
  console.error('加载项目helper失败，使用简易实现', e);
  // 简易helper实现
  helper = {
    isDefined: (val) => val !== undefined && val !== null,
    isEmpty: (val) => val === undefined || val === null || val === '',
    deepClone: (obj) => {
      if (obj === null || typeof obj !== 'object') return obj;
      if (obj instanceof Date) return new Date(obj);
      if (Array.isArray(obj)) return obj.map(item => helper.deepClone(item));
      const cloned = {};
      for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
          cloned[key] = helper.deepClone(obj[key]);
        }
      }
      return cloned;
    }
  };
}

// 尝试导入全局数据处理工具
let globalDataHelper;
try {
  globalDataHelper = require('../config/path_resolver.js').getRootConfigPath('path_resolver.js').getRootConfigPath('path_import.js').dataHelper;
  console.log('成功加载全局data_helper');
} catch (e) {
  console.warn('加载全局data_helper失败，使用本地实现', e);
  globalDataHelper = null;
}

// 安全的日期处理
function formatDate(date, format = 'YYYY-MM-DD') {
  if (!date) return '';
  const dt = new Date(date);
  const year = dt.getFullYear();
  const month = (dt.getMonth() + 1).toString().padStart(2, '0');
  const day = dt.getDate().toString().padStart(2, '0');
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day);
}

// 本地实现
const localImpl = {
  /**
   * 克隆数据（深拷贝）
   * @param {*} data - 要克隆的数据
   * @returns {*} 克隆后的数据
   */
  deepClone: function(data) {
    return helper.deepClone(data);
  },
  
  /**
   * 清理对象数据，去除不需要的字段
   * @param {Object} data - 源数据对象
   * @param {Array<string>} [except=[]] - 排除的字段
   * @returns {Object} 清理后的数据
   */
  pureData: function(data, except = []) {
    if (!data || typeof data !== 'object') return data;
    
    // 创建新对象
    const newData = {};
    
    for (const key in data) {
      if (data.hasOwnProperty(key) && !except.includes(key)) {
        if (key === '_id' || key === 'id') {
          newData[key] = data[key];
        } else if (typeof data[key] !== 'function') {
          newData[key] = data[key];
        }
      }
    }
    
    return newData;
  },
  
  /**
   * 提取对象中指定字段
   * @param {Object} obj - 源对象
   * @param {Array<string>} fields - 需要的字段数组
   * @returns {Object} 提取出的对象
   */
  getFields: function(obj, fields) {
    if (!obj || !fields || !Array.isArray(fields)) return {};
    
    const result = {};
    fields.forEach(field => {
      if (obj[field] !== undefined) {
        result[field] = obj[field];
      }
    });
    
    return result;
  },
  
  /**
   * 对象数组排序
   * @param {Array<Object>} arr - 对象数组
   * @param {string} key - 排序字段
   * @param {string} [sort='asc'] - 排序方式，asc升序，desc降序
   * @returns {Array<Object>} 排序后的数组
   */
  sortObjectArray: function(arr, key, sort = 'asc') {
    if (!arr || !Array.isArray(arr) || arr.length === 0) return [];
    
    return [...arr].sort((a, b) => {
      if (sort === 'asc') {
        return a[key] > b[key] ? 1 : -1;
      } else {
        return a[key] < b[key] ? 1 : -1;
      }
    });
  },
  
  /**
   * 数组去重
   * @param {Array} arr - 源数组
   * @param {string} [field] - 对象数组时，用于比较的字段
   * @returns {Array} 去重后的数组
   */
  uniqueArray: function(arr, field) {
    if (!arr || !Array.isArray(arr)) return [];
    
    if (field) {
      // 对象数组根据字段去重
      const map = new Map();
      arr.forEach(item => {
        if (!map.has(item[field])) {
          map.set(item[field], item);
        }
      });
      return Array.from(map.values());
    } else {
      // 普通数组去重
      return [...new Set(arr)];
    }
  },
  
  /**
   * 合并对象，与Object.assign类似，但会进行深度合并
   * @param {Object} target - 目标对象
   * @param {...Object} sources - 源对象
   * @returns {Object} 合并后的对象
   */
  mergeObjects: function(target, ...sources) {
    if (!target) return {};
    
    const result = this.deepClone(target);
    
    sources.forEach(source => {
      if (!source) return;
      
      Object.keys(source).forEach(key => {
        if (helper.isObject(source[key]) && helper.isObject(result[key])) {
          // 如果两者都是对象，进行深度合并
          result[key] = this.mergeObjects(result[key], source[key]);
        } else {
          // 否则直接赋值
          result[key] = source[key];
        }
      });
    });
    
    return result;
  },
  
  // 模拟全局日期处理
  time: function(date) {
    return formatDate(date);
  },
  
  timestamp: function() {
    return Math.floor(Date.now() / 1000);
  },
  
  // 处理时间范围
  getTimeSet: function(startDt, endDt = null) {
    if (!startDt) return null;
    let startTime, endTime;
    
    // 如果是日期对象，转换为时间戳
    if (startDt instanceof Date) {
      startTime = Math.floor(startDt.getTime() / 1000);
    } 
    // 如果是日期字符串，解析为时间戳
    else if (typeof startDt === 'string') {
      startTime = Math.floor(new Date(startDt.replace(/-/g, '/')).getTime() / 1000);
    } 
    // 如果已经是数字，直接使用
    else if (typeof startDt === 'number') {
      startTime = startDt;
    } else {
      return null;
    }
    
    // 处理结束时间
    if (endDt) {
      if (endDt instanceof Date) {
        endTime = Math.floor(endDt.getTime() / 1000);
      } else if (typeof endDt === 'string') {
        endTime = Math.floor(new Date(endDt.replace(/-/g, '/')).getTime() / 1000);
      } else if (typeof endDt === 'number') {
        endTime = endDt;
      }
    }
    
    if (endTime) {
      return { start: startTime, end: endTime };
    } else {
      return { start: startTime };
    }
  },
  
  // 序列化为可存储形式
  stringify: function(data) {
    try {
      return JSON.stringify(data);
    } catch (e) {
      console.error('数据序列化失败:', e);
      return '';
    }
  },
  
  // 反序列化数据
  parse: function(data) {
    if (!data) return null;
    try {
      return JSON.parse(data);
    } catch (e) {
      console.error('数据解析失败:', e);
      return null;
    }
  },
  
  // 获取随机ID
  genRandomID: function(length = 32) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
  }
};

// 使用全局实现或本地实现
const dataHelper = globalDataHelper || localImpl;

// 导出模块
module.exports = dataHelper;
